import { MqttMessage, DeviceData, DataPoint } from '../types';
import { InfluxService } from './InfluxService';

export class DataProcessor {
  private influxService: InfluxService;

  constructor() {
    this.influxService = new InfluxService();
  }

  async processMessage(message: MqttMessage): Promise<void> {
    try {
      // 解析消息负载
      const deviceData = this.parseMessage(message);
      
      if (!deviceData) {
        console.warn('⚠️ 无法解析消息数据');
        return;
      }

      console.log(`📊 处理设备数据 - 设备ID: ${deviceData.deviceId}`, deviceData);

      // 转换为InfluxDB数据点
      // const dataPoints = this.convertToDataPoints(deviceData, message.topic);

      // 写入InfluxDB
      // await this.influxService.writePoints(dataPoints);

      // 这里可以添加其他处理逻辑，如：
      // - 数据验证
      // - 告警检查
      // - 数据转发
      // - 缓存更新等

    } catch (error) {
      console.error('❌ 数据处理失败:', error);
    }
  }

  private parseMessage(message: MqttMessage): DeviceData | null {
    try {
      const payloadStr = message.payload.toString();
      
      // 尝试解析JSON格式的消息
      let parsedData: any;
      try {
        parsedData = JSON.parse(payloadStr);
      } catch {
        // 如果不是JSON格式，创建简单的数据结构
        parsedData = { rawData: payloadStr };
      }

      // 从主题中提取设备ID（假设主题格式为 testzqh/devices/{deviceId}/data）
      const topicParts = message.topic.split('/');
      const deviceId = topicParts[2] || 'unknown';

      return {
        deviceId,
        timestamp: Date.now(),
        data: parsedData,
        messageType: topicParts[2] || 'data', // data, status, alarm 等
      };

    } catch (error) {
      console.error('❌ 消息解析失败:', error);
      return null;
    }
  }

  private convertToDataPoints(deviceData: DeviceData, topic: string): DataPoint[] {
    const dataPoints: DataPoint[] = [];
    const timestamp = new Date(deviceData.timestamp);

    // 基础标签
    const baseTags = {
      deviceId: deviceData.deviceId,
      messageType: deviceData.messageType || 'data',
    };

    // 根据数据类型创建不同的测量点
    if (typeof deviceData.data === 'object' && deviceData.data !== null) {
      // 处理对象类型的数据
      Object.entries(deviceData.data).forEach(([key, value]) => {
        if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean') {
          dataPoints.push({
            measurement: 'device_metrics',
            tags: {
              ...baseTags,
              metric: key,
            },
            fields: {
              value: value,
            },
            timestamp,
          });
        }
      });
    } else {
      // 处理简单类型的数据
      dataPoints.push({
        measurement: 'device_data',
        tags: baseTags,
        fields: {
          value: deviceData.data,
        },
        timestamp,
      });
    }

    return dataPoints;
  }

  // 数据验证方法（可根据需要扩展）
  private validateDeviceData(data: DeviceData): boolean {
    return !!(data.deviceId && data.timestamp && data.data);
  }

  // 告警检查方法（可根据需要扩展）
  private checkAlarms(data: DeviceData): void {
    // 在这里实现告警逻辑
    // 例如：温度过高、设备离线等
  }
}
